પાયથન FastAPI મિડલવેર: રિક્વેસ્ટ અને રિસ્પોન્સ પ્રોસેસિંગ માટે એક વિસ્તૃત માર્ગદર્શિકા

આધુનિક વેબ ડેવલપમેન્ટની દુનિયામાં, પરફોર્મન્સ, સુરક્ષા અને જાળવણીક્ષમતા સર્વોપરી છે. પાયથનનું FastAPI ફ્રેમવર્ક તેની અવિશ્વસનીય ગતિ અને ડેવલપર-ફ્રેન્ડલી સુવિધાઓ માટે ઝડપથી લોકપ્રિય બન્યું છે. તેની સૌથી શક્તિશાળી છતાં ક્યારેક ગેરસમજ થતી સુવિધામાંથી એક છે મિડલવેર. મિડલવેર રિક્વેસ્ટ અને રિસ્પોન્સ પ્રોસેસિંગની શૃંખલામાં એક નિર્ણાયક કડી તરીકે કામ કરે છે, જે ડેવલપર્સને રિક્વેસ્ટ તેના ગંતવ્ય સુધી પહોંચે તે પહેલાં અથવા રિસ્પોન્સ ક્લાયન્ટને પાછો મોકલવામાં આવે તે પહેલાં કોડ ચલાવવા, ડેટામાં ફેરફાર કરવા અને નિયમો લાગુ કરવાની મંજૂરી આપે છે.

આ વિસ્તૃત માર્ગદર્શિકા ડેવલપર્સના વૈશ્વિક સમુદાય માટે બનાવવામાં આવી છે, જેમાં FastAPI સાથે હમણાં જ શરૂઆત કરનારાઓથી લઈને તેમની સમજને વધુ ઊંડી બનાવવા માંગતા અનુભવી વ્યાવસાયિકોનો સમાવેશ થાય છે. અમે મિડલવેરના મુખ્ય ખ્યાલોનું અન્વેષણ કરીશું, કસ્ટમ સોલ્યુશન્સ કેવી રીતે બનાવવું તે દર્શાવીશું, અને વ્યવહારુ, વાસ્તવિક-દુનિયાના ઉપયોગના કિસ્સાઓમાંથી પસાર થઈશું. અંત સુધીમાં, તમે વધુ મજબૂત, સુરક્ષિત અને કાર્યક્ષમ APIs બનાવવા માટે મિડલવેરનો લાભ લેવા માટે સજ્જ હશો.

વેબ ફ્રેમવર્કના સંદર્ભમાં મિડલવેર શું છે?

કોડમાં ઊંડા ઉતરતા પહેલાં, આ ખ્યાલને સમજવો જરૂરી છે. તમારી એપ્લિકેશનના રિક્વેસ્ટ-રિસ્પોન્સ ચક્રને પાઇપલાઇન અથવા એસેમ્બલી લાઇન તરીકે કલ્પના કરો. જ્યારે કોઈ ક્લાયન્ટ તમારા API પર રિક્વેસ્ટ મોકલે છે, ત્યારે તે તરત જ તમારા એન્ડપોઇન્ટ લોજિક પર નથી પહોંચતી. તેના બદલે, તે પ્રોસેસિંગના અનેક પગલાંઓમાંથી પસાર થાય છે. તેવી જ રીતે, જ્યારે તમારો એન્ડપોઇન્ટ રિસ્પોન્સ જનરેટ કરે છે, ત્યારે તે ક્લાયન્ટ સુધી પહોંચતા પહેલાં આ જ પગલાંઓમાંથી પાછો પસાર થાય છે. મિડલવેર ઘટકો પાઇપલાઇનમાં આ જ પગલાંઓ છે.

એક લોકપ્રિય ઉપમા ડુંગળી મોડેલ છે. ડુંગળીનું કેન્દ્ર તમારી એપ્લિકેશનનું બિઝનેસ લોજિક (એન્ડપોઇન્ટ) છે. કેન્દ્રની આસપાસના ડુંગળીના દરેક સ્તર મિડલવેરનો એક ભાગ છે. રિક્વેસ્ટને કેન્દ્ર સુધી પહોંચવા માટે દરેક બાહ્ય સ્તરને પાર કરવું પડે છે, અને રિસ્પોન્સ એ જ સ્તરોમાંથી પાછો બહાર આવે છે. દરેક સ્તર અંદર આવતી રિક્વેસ્ટ અને બહાર જતા રિસ્પોન્સનું નિરીક્ષણ અને તેમાં ફેરફાર કરી શકે છે.

સારમાં, મિડલવેર એક ફંક્શન અથવા ક્લાસ છે જે રિક્વેસ્ટ ઓબ્જેક્ટ, રિસ્પોન્સ ઓબ્જેક્ટ અને એપ્લિકેશનના રિક્વેસ્ટ-રિસ્પોન્સ ચક્રમાં આગલા મિડલવેર સુધી પહોંચી શકે છે. તેના મુખ્ય હેતુઓમાં શામેલ છે:

• કોડ ચલાવવો: દરેક આવતી રિક્વેસ્ટ માટે ક્રિયાઓ કરવી, જેમ કે લોગિંગ અથવા પરફોર્મન્સ મોનિટરિંગ.
• રિક્વેસ્ટ અને રિસ્પોન્સમાં ફેરફાર કરવો: હેડર્સ ઉમેરવા, રિસ્પોન્સ બોડીને કોમ્પ્રેસ કરવી, અથવા ડેટા ફોર્મેટમાં રૂપાંતર કરવું.
• ચક્રને ટૂંકાવવું: રિક્વેસ્ટ-રિસ્પોન્સ ચક્રને વહેલું સમાપ્ત કરવું. ઉદાહરણ તરીકે, ઓથેન્ટિકેશન મિડલવેર એક અનઓથેન્ટિકેટેડ રિક્વેસ્ટને તેના નિર્ધારિત એન્ડપોઇન્ટ સુધી પહોંચતા પહેલાં જ રોકી શકે છે.
• વૈશ્વિક ચિંતાઓનું સંચાલન કરવું: એરર હેન્ડલિંગ, CORS (ક્રોસ-ઓરિજિન રિસોર્સ શેરિંગ), અને સેશન મેનેજમેન્ટ જેવી ક્રોસ-કટિંગ ચિંતાઓને એક કેન્દ્રિય સ્થાન પર સંભાળવી.

FastAPI Starlette ટૂલકિટ પર બનેલું છે, જે ASGI (Asynchronous Server Gateway Interface) સ્ટાન્ડર્ડનું એક મજબૂત અમલીકરણ પૂરું પાડે છે. મિડલવેર ASGI માં એક મૂળભૂત ખ્યાલ છે, જે તેને FastAPI ઇકોસિસ્ટમમાં પ્રથમ-વર્ગનો નાગરિક બનાવે છે.

સૌથી સરળ સ્વરૂપ: ડેકોરેટર સાથે FastAPI મિડલવેર

FastAPI @app.middleware("http") ડેકોરેટરનો ઉપયોગ કરીને મિડલવેર ઉમેરવાની એક સીધી રીત પ્રદાન કરે છે. આ સરળ, સ્વ-નિર્ભર લોજિક માટે ઉત્તમ છે જેને દરેક HTTP રિક્વેસ્ટ માટે ચલાવવાની જરૂર હોય છે.

ચાલો એક ક્લાસિક ઉદાહરણ બનાવીએ: દરેક રિક્વેસ્ટ માટે પ્રોસેસિંગ સમયની ગણતરી કરવા અને તેને રિસ્પોન્સ હેડર્સમાં ઉમેરવા માટે એક મિડલવેર. આ પરફોર્મન્સ મોનિટરિંગ માટે અત્યંત ઉપયોગી છે.

ઉદાહરણ: પ્રોસેસ-ટાઇમ મિડલવેર

પ્રથમ, ખાતરી કરો કે તમારી પાસે FastAPI અને Uvicorn જેવો ASGI સર્વર ઇન્સ્ટોલ કરેલો છે:

pip install fastapi uvicorn

હવે, ચાલો main.py નામની ફાઇલમાં કોડ લખીએ:

import time

from fastapi import FastAPI, Request

app = FastAPI()

# મિડલવેર ફંક્શનને વ્યાખ્યાયિત કરો

@app.middleware("http")

async def add_process_time_header(request: Request, call_next):

# જ્યારે રિક્વેસ્ટ આવે ત્યારે શરૂઆતનો સમય રેકોર્ડ કરો

start_time = time.time()

# આગલા મિડલવેર અથવા એન્ડપોઇન્ટ પર આગળ વધો

response = await call_next(request)

# પ્રોસેસિંગ સમયની ગણતરી કરો

process_time = time.time() - start_time

# રિસ્પોન્સમાં કસ્ટમ હેડર ઉમેરો

response.headers["X-Process-Time"] = str(process_time)

return response

@app.get("/")

async def root():

# થોડું કામનું અનુકરણ કરો

time.sleep(0.5)

return {"message": "Hello, World!"}

આ એપ્લિકેશન ચલાવવા માટે, આદેશનો ઉપયોગ કરો:

uvicorn main:app --reload

હવે, જો તમે cURL જેવા ટૂલ અથવા Postman જેવા API ક્લાયન્ટનો ઉપયોગ કરીને http://127.0.0.1:8000 પર રિક્વેસ્ટ મોકલો છો, તો તમને રિસ્પોન્સમાં એક નવું હેડર, X-Process-Time, દેખાશે, જેનું મૂલ્ય લગભગ 0.5 સેકન્ડ હશે.

કોડનું વિશ્લેષણ:

• @app.middleware("http"): આ ડેકોરેટર અમારા ફંક્શનને HTTP મિડલવેરના એક ભાગ તરીકે રજીસ્ટર કરે છે.
• async def add_process_time_header(request: Request, call_next):: મિડલવેર ફંક્શન અસિંક્રોનસ હોવું જોઈએ. તે આવનારા Request ઓબ્જેક્ટ અને એક ખાસ ફંક્શન, call_next મેળવે છે.
• response = await call_next(request): આ સૌથી નિર્ણાયક લાઇન છે. call_next રિક્વેસ્ટને પાઇપલાઇનના આગલા પગલા પર મોકલે છે (ક્યાં તો અન્ય મિડલવેર અથવા વાસ્તવિક પાથ ઓપરેશન). તમારે આ કોલને must `await` કરવો જ પડશે. તેનું પરિણામ એન્ડપોઇન્ટ દ્વારા જનરેટ થયેલ Response ઓબ્જેક્ટ છે.
• response.headers[...] = ...: એન્ડપોઇન્ટમાંથી રિસ્પોન્સ મળ્યા પછી, અમે તેમાં ફેરફાર કરી શકીએ છીએ, આ કિસ્સામાં, કસ્ટમ હેડર ઉમેરીને.
• return response: છેલ્લે, ફેરફાર કરેલો રિસ્પોન્સ ક્લાયન્ટને મોકલવા માટે પરત કરવામાં આવે છે.

ક્લાસ સાથે તમારું પોતાનું કસ્ટમ મિડલવેર બનાવવું

જ્યારે ડેકોરેટર અભિગમ સરળ છે, તે વધુ જટિલ પરિસ્થિતિઓ માટે મર્યાદિત બની શકે છે, ખાસ કરીને જ્યારે તમારા મિડલવેરને ગોઠવણીની જરૂર હોય અથવા કેટલીક આંતરિક સ્થિતિનું સંચાલન કરવાની જરૂર હોય. આ કિસ્સાઓ માટે, FastAPI (Starlette દ્વારા) BaseHTTPMiddleware નો ઉપયોગ કરીને ક્લાસ-આધારિત મિડલવેરને સપોર્ટ કરે છે.

ક્લાસ-આધારિત અભિગમ વધુ સારી રચના પ્રદાન કરે છે, તેના કન્સ્ટ્રક્ટરમાં ડિપેન્ડન્સી ઇન્જેક્શનની મંજૂરી આપે છે, અને સામાન્ય રીતે જટિલ લોજિક માટે વધુ જાળવણીક્ષમ છે. મુખ્ય લોજિક અસિંક્રોનસ dispatch પદ્ધતિમાં રહે છે.

ઉદાહરણ: ક્લાસ-આધારિત API કી ઓથેન્ટિકેશન મિડલવેર

ચાલો એક વધુ વ્યવહારુ મિડલવેર બનાવીએ જે આપણા API ને સુરક્ષિત કરે. તે એક વિશિષ્ટ હેડર, X-API-Key, માટે તપાસ કરશે, અને જો કી હાજર ન હોય અથવા અમાન્ય હોય, તો તે તરત જ 403 Forbidden એરર રિસ્પોન્સ પરત કરશે. આ રિક્વેસ્ટને "શોર્ટ-સર્કિટ" કરવાનું એક ઉદાહરણ છે.

main.py માં:

from fastapi import FastAPI, Request

from fastapi.responses import JSONResponse

from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint

from starlette.responses import Response

# માન્ય API કીની સૂચિ. વાસ્તવિક એપ્લિકેશનમાં, આ ડેટાબેઝ અથવા સુરક્ષિત વોલ્ટમાંથી આવશે.

VALID_API_KEYS = ["my-super-secret-key", "another-valid-key"]

class APIKeyMiddleware(BaseHTTPMiddleware):

async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:

api_key = request.headers.get("X-API-Key")

if api_key not in VALID_API_KEYS:

# રિક્વેસ્ટને શોર્ટ-સર્કિટ કરો અને એરર રિસ્પોન્સ પરત કરો

return JSONResponse(

status_code=403,

content={"detail": "Forbidden: Invalid or missing API Key"}

)

# જો કી માન્ય હોય, તો રિક્વેસ્ટ સાથે આગળ વધો

response = await call_next(request)

return response

app = FastAPI()

# એપ્લિકેશનમાં મિડલવેર ઉમેરો

app.add_middleware(APIKeyMiddleware)

@app.get("/")

async def root():

return {"message": "Welcome to the secure zone!"}

હવે, જ્યારે તમે આ એપ્લિકેશન ચલાવો છો:

• X-API-Key હેડર વગર (અથવા ખોટા મૂલ્ય સાથે) મોકલેલી રિક્વેસ્ટને 403 સ્ટેટસ કોડ અને JSON એરર મેસેજ મળશે.
• X-API-Key: my-super-secret-key હેડર સાથે મોકલેલી રિક્વેસ્ટ સફળ થશે અને 200 OK રિસ્પોન્સ મળશે.

આ પેટર્ન અત્યંત શક્તિશાળી છે. / પરના એન્ડપોઇન્ટ કોડને API કી વેલિડેશન વિશે કંઈપણ જાણવાની જરૂર નથી; તે ચિંતા સંપૂર્ણપણે મિડલવેર સ્તરમાં અલગ પાડવામાં આવી છે.

મિડલવેર માટે સામાન્ય અને શક્તિશાળી ઉપયોગના કિસ્સાઓ

મિડલવેર ક્રોસ-કટિંગ ચિંતાઓને સંભાળવા માટેનું સંપૂર્ણ સાધન છે. ચાલો કેટલાક સૌથી સામાન્ય અને પ્રભાવશાળી ઉપયોગના કિસ્સાઓનું અન્વેષણ કરીએ.

1. કેન્દ્રિય લોગિંગ

ઉત્પાદન એપ્લિકેશનો માટે વ્યાપક લોગિંગ અનિવાર્ય છે. મિડલવેર તમને એક જ બિંદુ બનાવવાની મંજૂરી આપે છે જ્યાં તમે દરેક રિક્વેસ્ટ અને તેના સંબંધિત રિસ્પોન્સ વિશેની નિર્ણાયક માહિતી લોગ કરો છો.

ઉદાહરણ લોગિંગ મિડલવેર:

import logging

from fastapi import FastAPI, Request

import time

logging.basicConfig(level=logging.INFO)

logger = logging.getLogger(__name__)

app = FastAPI()

@app.middleware("http")

async def logging_middleware(request: Request, call_next):

start_time = time.time()

# રિક્વેસ્ટ વિગતો લોગ કરો

logger.info(f"Incoming request: {request.method} {request.url.path}")

response = await call_next(request)

process_time = time.time() - start_time

# રિસ્પોન્સ વિગતો લોગ કરો

logger.info(f"Response status: {response.status_code} | Process time: {process_time:.4f}s")

return response

આ મિડલવેર આવતી વખતે રિક્વેસ્ટ મેથડ અને પાથને લોગ કરે છે, અને જતી વખતે રિસ્પોન્સ સ્ટેટસ કોડ અને કુલ પ્રોસેસિંગ સમયને લોગ કરે છે. આ તમારી એપ્લિકેશનના ટ્રાફિકમાં અમૂલ્ય દૃશ્યતા પ્રદાન કરે છે.

2. વૈશ્વિક એરર હેન્ડલિંગ

ડિફૉલ્ટ રૂપે, તમારા કોડમાં એક અનહેન્ડલ્ડ એક્સેપ્શન 500 ઇન્ટરનલ સર્વર એરરમાં પરિણમશે, જે સંભવિત રીતે સ્ટેક ટ્રેસ અને અમલીકરણ વિગતો ક્લાયન્ટને જાહેર કરી શકે છે. એક વૈશ્વિક એરર હેન્ડલિંગ મિડલવેર તમામ એક્સેપ્શનને પકડી શકે છે, તેમને આંતરિક સમીક્ષા માટે લોગ કરી શકે છે, અને એક પ્રમાણભૂત, વપરાશકર્તા-મૈત્રીપૂર્ણ એરર રિસ્પોન્સ પરત કરી શકે છે.

ઉદાહરણ એરર હેન્ડલિંગ મિડલવેર:

from fastapi import FastAPI, Request

from fastapi.responses import JSONResponse

import logging

logger = logging.getLogger(__name__)

app = FastAPI()

@app.middleware("http")

async def error_handling_middleware(request: Request, call_next):

try:

return await call_next(request)

except Exception as e:

logger.error(f"An unhandled error occurred: {e}", exc_info=True)

return JSONResponse(

status_code=500,

content={"detail": "An internal server error occurred. Please try again later."}

)

@app.get("/error")

async def cause_error():

return 1 / 0 # આ એક ZeroDivisionError ઉભી કરશે

આ મિડલવેર સાથે, /error પરની રિક્વેસ્ટ હવે સર્વરને ક્રેશ નહીં કરે અથવા સ્ટેક ટ્રેસને જાહેર નહીં કરે. તેના બદલે, તે સુંદર રીતે 500 સ્ટેટસ કોડ સાથે સ્વચ્છ JSON બોડી પરત કરશે, જ્યારે સંપૂર્ણ એરર ડેવલપર્સ દ્વારા તપાસ માટે સર્વર-સાઇડ પર લોગ કરવામાં આવશે.

3. CORS (ક્રોસ-ઓરિજિન રિસોર્સ શેરિંગ)

જો તમારી ફ્રન્ટએન્ડ એપ્લિકેશન તમારા FastAPI બેકએન્ડ કરતાં અલગ ડોમેન, પ્રોટોકોલ અથવા પોર્ટ પરથી સેવા આપવામાં આવે છે, તો બ્રાઉઝર્સ સમાન-ઓરિજિન નીતિને કારણે રિક્વેસ્ટને બ્લોક કરશે. CORS આ નીતિને હળવી કરવાની પદ્ધતિ છે. FastAPI આ ચોક્કસ હેતુ માટે એક સમર્પિત, અત્યંત રૂપરેખાંકિત `CORSMiddleware` પ્રદાન કરે છે.

ઉદાહરણ CORS રૂપરેખાંકન:

from fastapi import FastAPI

from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

# મંજૂર ઓરિજિન્સની સૂચિ વ્યાખ્યાયિત કરો. સાર્વજનિક APIs માટે "*" નો ઉપયોગ કરો, પરંતુ વધુ સારી સુરક્ષા માટે વિશિષ્ટ રહો.

origins = [

"http://localhost:3000",

"https://my-production-frontend.com",

]

app.add_middleware(

CORSMiddleware,

allow_origins=origins,

allow_credentials=True, # ક્રોસ-ઓરિજિન રિક્વેસ્ટમાં કૂકીઝને શામેલ કરવાની મંજૂરી આપો

allow_methods=["*"], # તમામ પ્રમાણભૂત HTTP પદ્ધતિઓને મંજૂરી આપો

allow_headers=["*"], # તમામ હેડર્સને મંજૂરી આપો

)

આ એવા પ્રથમ મિડલવેરમાંનું એક છે જે તમે સંભવતઃ કોઈપણ પ્રોજેક્ટમાં ડિ-કપલ્ડ ફ્રન્ટએન્ડ સાથે ઉમેરશો, જે એક જ, કેન્દ્રીય સ્થાનથી ક્રોસ-ઓરિજિન નીતિઓનું સંચાલન કરવાનું સરળ બનાવે છે.

4. GZip કમ્પ્રેશન

HTTP રિસ્પોન્સને કોમ્પ્રેસ કરવાથી તેમના કદમાં નોંધપાત્ર ઘટાડો થઈ શકે છે, જેનાથી ક્લાયન્ટ્સ માટે ઝડપી લોડ સમય અને ઓછો બેન્ડવિડ્થ ખર્ચ થાય છે. FastAPI આને આપમેળે સંભાળવા માટે `GZipMiddleware` શામેલ કરે છે.

ઉદાહરણ GZip મિડલવેર:

from fastapi import FastAPI

from fastapi.middleware.gzip import GZipMiddleware

app = FastAPI()

# GZip મિડલવેર ઉમેરો. તમે કમ્પ્રેશન માટે ન્યૂનતમ કદ સેટ કરી શકો છો.

app.add_middleware(GZipMiddleware, minimum_size=1000)

@app.get("/")

async def root():

# આ રિસ્પોન્સ નાનો છે અને તે gzip થશે નહીં.

return {"message": "Hello World"}

@app.get("/large-data")

async def large_data():

# આ મોટો રિસ્પોન્સ મિડલવેર દ્વારા આપમેળે gzip થશે.

return {"data": "a_very_long_string..." * 1000}

આ મિડલવેર સાથે, 1000 બાઇટ્સ કરતાં મોટો કોઈપણ રિસ્પોન્સ કોમ્પ્રેસ થશે જો ક્લાયન્ટ સૂચવે કે તે GZip એન્કોડિંગ સ્વીકારે છે (જે વર્ચ્યુઅલી તમામ આધુનિક બ્રાઉઝર્સ અને ક્લાયન્ટ્સ કરે છે).

અદ્યતન ખ્યાલો અને શ્રેષ્ઠ પદ્ધતિઓ

જેમ જેમ તમે મિડલવેર સાથે વધુ નિપુણ બનો છો, તેમ તેમ સ્વચ્છ, કાર્યક્ષમ અને અનુમાનિત કોડ લખવા માટે કેટલીક સૂક્ષ્મતા અને શ્રેષ્ઠ પદ્ધતિઓને સમજવું મહત્વપૂર્ણ છે.

1. મિડલવેરનો ક્રમ મહત્વપૂર્ણ છે!

આ યાદ રાખવાનો સૌથી નિર્ણાયક નિયમ છે. મિડલવેરને તે ક્રમમાં પ્રોસેસ કરવામાં આવે છે જે ક્રમમાં તેને એપ્લિકેશનમાં ઉમેરવામાં આવે છે. પ્રથમ ઉમેરાયેલું મિડલવેર "ડુંગળી" નું સૌથી બહારનું સ્તર છે.

આ સેટઅપને ધ્યાનમાં લો:

app.add_middleware(ErrorHandlingMiddleware) # સૌથી બહારનું

app.add_middleware(LoggingMiddleware)

app.add_middleware(AuthenticationMiddleware) # સૌથી અંદરનું

રિક્વેસ્ટનો પ્રવાહ આ પ્રમાણે હશે:

1. ErrorHandlingMiddleware રિક્વેસ્ટ મેળવે છે. તે તેના `call_next` ને `try...except` બ્લોકમાં લપેટે છે.
2. તે `next` ને કોલ કરે છે, રિક્વેસ્ટને `LoggingMiddleware` પર મોકલે છે.
3. LoggingMiddleware રિક્વેસ્ટ મેળવે છે, તેને લોગ કરે છે, અને `next` ને કોલ કરે છે.
4. AuthenticationMiddleware રિક્વેસ્ટ મેળવે છે, ઓળખપત્રોને માન્ય કરે છે, અને `next` ને કોલ કરે છે.
5. રિક્વેસ્ટ છેવટે એન્ડપોઇન્ટ પર પહોંચે છે.
6. એન્ડપોઇન્ટ રિસ્પોન્સ પરત કરે છે.
7. AuthenticationMiddleware રિસ્પોન્સ મેળવે છે અને તેને ઉપર મોકલે છે.
8. LoggingMiddleware રિસ્પોન્સ મેળવે છે, તેને લોગ કરે છે, અને તેને ઉપર મોકલે છે.
9. ErrorHandlingMiddleware અંતિમ રિસ્પોન્સ મેળવે છે અને તેને ક્લાયન્ટને પરત કરે છે.

આ ક્રમ તાર્કિક છે: એરર હેન્ડલર બહારની બાજુએ છે જેથી તે કોઈપણ પછીના સ્તરમાંથી આવતી એરરને પકડી શકે, જેમાં અન્ય મિડલવેરનો પણ સમાવેશ થાય છે. ઓથેન્ટિકેશન સ્તર અંદરની બાજુએ છે, જેથી આપણે એવી રિક્વેસ્ટને લોગ કરવામાં કે પ્રોસેસ કરવામાં સમય બગાડતા નથી જે કોઈપણ રીતે નકારી કાઢવામાં આવવાની છે.

2. `request.state` સાથે ડેટા પસાર કરવો

ક્યારેક, મિડલવેરને એન્ડપોઇન્ટ પર માહિતી પસાર કરવાની જરૂર પડે છે. ઉદાહરણ તરીકે, ઓથેન્ટિકેશન મિડલવેર JWT ને ડીકોડ કરી શકે છે અને વપરાશકર્તાની ID કાઢી શકે છે. તે આ વપરાશકર્તા ID ને પાથ ઓપરેશન ફંક્શન માટે કેવી રીતે ઉપલબ્ધ કરાવી શકે?

ખોટી રીત એ છે કે રિક્વેસ્ટ ઓબ્જેક્ટમાં સીધો ફેરફાર કરવો. સાચી રીત request.state ઓબ્જેક્ટનો ઉપયોગ કરવો છે. તે આ ચોક્કસ હેતુ માટે પૂરો પાડવામાં આવેલ એક સરળ, ખાલી ઓબ્જેક્ટ છે.

ઉદાહરણ: મિડલવેરમાંથી વપરાશકર્તા ડેટા પસાર કરવો

# તમારા ઓથેન્ટિકેશન મિડલવેરની dispatch પદ્ધતિમાં:

# ... ટોકનને માન્ય કર્યા પછી અને વપરાશકર્તાને ડીકોડ કર્યા પછી ...

user_data = {"id": 123, "username": "global_dev"}

request.state.user = user_data

response = await call_next(request)

# તમારા એન્ડપોઇન્ટમાં:

@app.get("/profile")

async def get_user_profile(request: Request):

current_user = request.state.user

return {"profile_for": current_user}

આ લોજિકને સ્વચ્છ રાખે છે અને `Request` ઓબ્જેક્ટના નેમસ્પેસને પ્રદૂષિત થવાથી બચાવે છે.

3. પરફોર્મન્સ સંબંધિત વિચારણાઓ

જ્યારે મિડલવેર શક્તિશાળી છે, ત્યારે દરેક સ્તર થોડો ઓવરહેડ ઉમેરે છે. ઉચ્ચ-પ્રદર્શન એપ્લિકેશનો માટે, આ મુદ્દાઓને ધ્યાનમાં રાખો:

• તેને સંક્ષિપ્ત રાખો: મિડલવેર લોજિક શક્ય તેટલું ઝડપી અને કાર્યક્ષમ હોવું જોઈએ.
• અસિંક્રોનસ બનો: જો તમારા મિડલવેરને I/O ઓપરેશન્સ (જેમ કે ડેટાબેઝ ચેક) કરવાની જરૂર હોય, તો ખાતરી કરો કે તે સંપૂર્ણપણે `async` છે જેથી સર્વરના ઇવેન્ટ લૂપને બ્લોક થતું અટકે.
• હેતુ સાથે ઉપયોગ કરો: જે મિડલવેરની તમને જરૂર નથી તે ઉમેરશો નહીં. દરેક એક કોલ સ્ટેકની ઊંડાઈ અને પ્રોસેસિંગ સમયમાં વધારો કરે છે.

4. તમારા મિડલવેરનું પરીક્ષણ કરવું

મિડલવેર તમારી એપ્લિકેશનના લોજિકનો એક નિર્ણાયક ભાગ છે અને તેનું સંપૂર્ણ પરીક્ષણ કરવું જોઈએ. FastAPI નો `TestClient` આને સીધું બનાવે છે. તમે એવા પરીક્ષણો લખી શકો છો જે જરૂરી શરતો સાથે અને વગર (ઉદાહરણ તરીકે, માન્ય API કી સાથે અને વગર) રિક્વેસ્ટ મોકલે છે અને ખાતરી કરે છે કે મિડલવેર અપેક્ષા મુજબ વર્તે છે.

APIKeyMiddleware માટે ઉદાહરણ પરીક્ષણ:

from fastapi.testclient import TestClient

from .main import app # તમારી FastAPI એપને ઇમ્પોર્ટ કરો

client = TestClient(app)

def test_request_without_api_key_is_forbidden():

response = client.get("/")

assert response.status_code == 403

assert response.json() == {"detail": "Forbidden: Invalid or missing API Key"}

def test_request_with_valid_api_key_is_successful():

headers = {"X-API-Key": "my-super-secret-key"}

response = client.get("/", headers=headers)

assert response.status_code == 200

assert response.json() == {"message": "Welcome to the secure zone!"}

નિષ્કર્ષ

FastAPI મિડલવેર આધુનિક વેબ APIs બનાવનાર કોઈપણ ડેવલપર માટે એક મૂળભૂત અને શક્તિશાળી સાધન છે. તે ક્રોસ-કટિંગ ચિંતાઓને સંભાળવા માટે એક સુઘડ અને પુનઃઉપયોગી રીત પ્રદાન કરે છે, તેમને તમારા મુખ્ય બિઝનેસ લોજિકથી અલગ પાડે છે. દરેક રિક્વેસ્ટ અને રિસ્પોન્સને અટકાવીને અને પ્રોસેસ કરીને, મિડલવેર તમને મજબૂત લોગિંગ, કેન્દ્રિય એરર હેન્ડલિંગ, કડક સુરક્ષા નીતિઓ અને કમ્પ્રેશન જેવી પરફોર્મન્સ ઉન્નતિઓ લાગુ કરવાની મંજૂરી આપે છે.

સરળ @app.middleware("http") ડેકોરેટરથી લઈને જટિલ, ક્લાસ-આધારિત સોલ્યુશન્સ સુધી, તમારી જરૂરિયાતો માટે સાચો અભિગમ પસંદ કરવાની તમારી પાસે સુગમતા છે. મુખ્ય ખ્યાલો, સામાન્ય ઉપયોગના કિસ્સાઓ, અને મિડલવેર ઓર્ડરિંગ અને સ્ટેટ મેનેજમેન્ટ જેવી શ્રેષ્ઠ પદ્ધતિઓને સમજીને, તમે વધુ સ્વચ્છ, વધુ સુરક્ષિત અને અત્યંત જાળવણીક્ષમ FastAPI એપ્લિકેશનો બનાવી શકો છો.

હવે તમારો વારો છે. તમારા આગામી FastAPI પ્રોજેક્ટમાં કસ્ટમ મિડલવેરને એકીકૃત કરવાનું શરૂ કરો અને તમારી API ડિઝાઇનમાં નિયંત્રણ અને સુઘડતાના નવા સ્તરને અનલોક કરો. શક્યતાઓ વિશાળ છે, અને આ સુવિધામાં નિપુણતા મેળવવી નિઃશંકપણે તમને વધુ અસરકારક અને કાર્યક્ષમ ડેવલપર બનાવશે.